home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / p4 / p4-1_2b.lha / p4-1.2b / messages / grid_master.c < prev    next >
C/C++ Source or Header  |  1992-12-18  |  6KB  |  274 lines
  1. #include "p4.h"
  2.  
  3. #ifndef TRUE
  4. #define BOOL            int
  5. #define TRUE            1
  6. #define FALSE           0
  7. #endif
  8.  
  9. /*  the following numbers define a grid of 4 processes, plus one master */
  10. #define ROWS        100
  11. #define COLUMNS        100
  12.  
  13. #define ROWS_PER_SUB     50
  14. #define COLUMNS_PER_SUB 50
  15.  
  16.  
  17.  
  18. #define PROCS_PER_COL    (ROWS / ROWS_PER_SUB)
  19. #define PROCS_PER_ROW    (COLUMNS / COLUMNS_PER_SUB)
  20. #define N_PROCS        (PROCS_PER_ROW * PROCS_PER_COL)
  21.  
  22. /* message types */
  23. #define CNTL            0
  24. #define C_BOUNDARY    1
  25. #define R_BOUNDARY    2
  26. #define ANSWER          3
  27.  
  28. #define MASTER        0    /*master proc id */
  29.  
  30. struct cntl_rec {
  31.       int row;
  32.     int col;
  33.         int upper_neighbor;
  34.     int right_neighbor;
  35.     int lower_neighbor;
  36.     int left_neighbor;
  37.     int iterations;
  38.     double bounded_subgrid[ROWS_PER_SUB+2][COLUMNS_PER_SUB+2];
  39.     };
  40.  
  41. struct c_boundary {
  42.     double col[ROWS_PER_SUB];
  43.     };        
  44.  
  45. struct r_boundary {
  46.            double row[COLUMNS_PER_SUB];
  47.     };
  48.  
  49. struct answer_rec {
  50.     double subgrid[ROWS_PER_SUB][COLUMNS_PER_SUB];
  51.         };
  52.  
  53. double avggrid();
  54. double avgbnd();
  55.  
  56. /* some compilers require this to be outside main (too many locals) */
  57. double  grid[ROWS+2][COLUMNS+2];
  58.  
  59.  
  60. main(argc,argv)
  61. int argc;
  62. char *argv[];
  63. {
  64.  
  65.     struct cntl_rec rec1;
  66.     struct answer_rec *rec2;
  67.  
  68.     int        process_id[N_PROCS], proc_id;
  69.     int     proc, i, j, f_row, f_col, ln, msg_type;
  70.     int timestart, timeend;
  71.     double avg;
  72.  
  73.     p4_initenv(&argc,argv);
  74.     p4_create_procgroup();
  75.  
  76.     /*  old way - RL
  77.     gridinit(grid,ROWS+2,COLUMNS+2);
  78.     */
  79.     gridinit(grid,ROWS,COLUMNS);
  80.  
  81.     printf("Enter the number of iterations: ");
  82.     scanf("%d",&(rec1.iterations));        
  83.  
  84.     timestart = p4_clock();
  85.  
  86.     for (proc=0; proc < N_PROCS; proc++)
  87.     process_id[proc] = proc+1;
  88.  
  89.     for (proc=0; proc < N_PROCS; proc++)
  90.     {
  91.     rec1.row = first_row(proc);
  92.     rec1.col = first_column(proc);
  93.     rec1.left_neighbor = 0;
  94.     rec1.right_neighbor = 0;
  95.     rec1.upper_neighbor = 0;
  96.     rec1.lower_neighbor = 0;
  97.     if (!upper_bound(rec1.row)) {
  98.         i = rec1.row - ROWS_PER_SUB;
  99.         j = which_proc(i,rec1.col);
  100.         rec1.upper_neighbor = process_id[j];
  101.     }
  102.     if (!lower_bound(rec1.row)) {
  103.         i = rec1.row + ROWS_PER_SUB;
  104.         j = which_proc(i,rec1.col);
  105.         rec1.lower_neighbor = process_id[j];
  106.     }
  107.     if (!right_bound(rec1.col)) {
  108.         i = rec1.col + COLUMNS_PER_SUB;
  109.         j = which_proc(rec1.row,i);
  110.         rec1.right_neighbor = process_id[j];
  111.     }
  112.     if (!left_bound(rec1.col)) {
  113.         i = rec1.col - COLUMNS_PER_SUB;
  114.         j = which_proc(rec1.row,i);
  115.         rec1.left_neighbor = process_id[j];
  116.     }
  117.  
  118.     for (i=(rec1.row - 1); i <= (rec1.row + ROWS_PER_SUB); i++) 
  119.     {
  120.  
  121.         for (j=(rec1.col - 1); j <= (rec1.col + COLUMNS_PER_SUB); j++)
  122.         {
  123.         rec1.bounded_subgrid[(i-(rec1.row-1))][(j-(rec1.col-1))] =
  124.             grid[i][j];
  125.         }
  126.     }
  127.     ln = sizeof(struct cntl_rec);
  128.     p4_sendr(CNTL,process_id[proc],&rec1,ln);
  129.     }
  130.  
  131.     for (proc=0; proc < N_PROCS; proc++)
  132.     {
  133.     p4_dprintfl(5,"master receiving answer\n");
  134.     
  135.     msg_type = ANSWER;
  136.     proc_id = -1; 
  137.     rec2 = NULL;
  138.     p4_recv(&msg_type,&proc_id,&rec2,&ln);
  139.     p4_dprintfl(5,"master received answer from slave %d\n",proc_id);
  140.     f_row = first_row(proc_id - 1);
  141.     f_col = first_column(proc_id - 1);
  142.     for (i=0; i < ROWS_PER_SUB; i++) 
  143.         for (j=0; j < COLUMNS_PER_SUB; j++)
  144.         grid[f_row + i][f_col + j] = rec2->subgrid[i][j];
  145.     }
  146.     timeend = p4_clock();
  147.     p4_wait_for_end();
  148.     printf("total time %.3f seconds\n",(timeend - timestart)/1000.0);
  149.  
  150.     /* printgrid(grid,ROWS,COLUMNS); */
  151.     avg = avggrid(grid,ROWS,COLUMNS);
  152.     printf("average value of grid = %f\n",avg);
  153. }
  154.  
  155. first_row(proc)
  156. int proc;
  157. {
  158.     return(((proc / PROCS_PER_ROW) * ROWS_PER_SUB) + 1);
  159. }
  160.  
  161. first_column(proc)
  162. int proc;
  163. {
  164.     return(((proc % PROCS_PER_ROW) * COLUMNS_PER_SUB) + 1);
  165. }
  166.  
  167. which_proc(row,column)
  168. int row,column;
  169. {
  170.     return((((row - 1) / ROWS_PER_SUB) * PROCS_PER_ROW) + 
  171.        ((column - 1) / COLUMNS_PER_SUB));
  172. }
  173.  
  174. /* old way - RL
  175. gridinit(m,x,y)
  176. double m[ROWS+2][COLUMNS+2];
  177. int x,y;
  178. {
  179.     int i, j;
  180.  
  181.     for (i=0; i <= x-1; i++)
  182.         for (j=0; j <= y-1; j++)
  183.             m[i][j] = 0;
  184.  
  185.     for (j=0; j < y; j++)
  186.     {
  187.         m[0][j] = phi(1,j+1);
  188.         m[x-1][j]= phi(x+1,j+1);
  189.     }
  190.     for (i=0; i < x; i++)
  191.     {
  192.         m[i][0] = phi(i+1,1);
  193.         m[i][y-1] = phi(i+1,y+1);
  194.     }
  195. }
  196. */
  197.  
  198.  
  199. gridinit(m,r,c)
  200. double m[ROWS+2][COLUMNS+2];
  201. int r, c;
  202. {
  203.     int i, j;
  204.     double bndavg;
  205.     
  206.     for (j=0; j < (c + 2); j++)
  207.     {
  208.         m[0][j] = phi(1,j+1);
  209.         m[r+1][j]= phi(r+2,j+1);
  210.     }
  211.     for (i=1; i < (r + 2); i++)
  212.     {
  213.         m[i][0] = phi(i+1,1);
  214.         m[i][c+1] = phi(i+1,c+2);
  215.     }
  216.     bndavg = avgbnd(m,r,c);
  217.     printf("boundary average = %f\n",bndavg);
  218.  
  219.     /* initialize the interior of the grids to the average over the boundary*/
  220.     for (i=1; i <= r; i++)
  221.         for (j=1; j <= c; j++)
  222.             /* m[i][j] = bndavg; this optimization hinders debugging */
  223.         m[i][j] = 0;
  224. }
  225.  
  226. double avggrid(m,r,c)
  227. double m[ROWS+2][COLUMNS+2];
  228. int r,c;
  229. {
  230.     int i,j;
  231.     double avg = 0;
  232.  
  233.     for (i = 0; i < (r+2); i++)
  234.     for (j = 0; j < (c+2); j++)
  235.         avg += m[i][j];
  236.     return(avg/((r+2)*(c+2)));
  237. }
  238.  
  239. double avgbnd(m,r,c)
  240. double m[ROWS+2][COLUMNS+2];
  241. int r,c;
  242. {
  243.     int i,j;
  244.     double avg = 0;
  245.  
  246.     for (i = 0; i < (r+2); i++)
  247.         avg += m[i][0];
  248.     for (i = 0; i < (r+2); i++)
  249.         avg += m[i][c+1];
  250.     for (i = 1; i < (c+1); i++)
  251.         avg += m[0][i];
  252.     for (i = 1; i < (c+1); i++)
  253.         avg += m[r+1][i];
  254.     return(avg/(2*(c+2) + 2*(r+2) - 4)); /* average over boundary */
  255. }
  256.  
  257. phi(x,y)
  258. int x,y;
  259. {
  260.     return(x*x-y*y+x*y);
  261. }
  262.  
  263. printgrid(grid,r,c)
  264. double grid[ROWS+2][COLUMNS+2];
  265. int r,c;
  266. {
  267.     int i,j;
  268.  
  269.     for (i = 0; i < (r+2); i++)
  270.     for (j = 0; j < (c+2); j++)
  271.         printf("grid[%3d][%3d] = %10.5f\n",i,j,grid[i][j]);
  272. }
  273.  
  274.